Bounded-Degree Techniques Accelerate Some Parameterized Graph Algorithms

Many algorithms for FPT graph problems are search tree algorithms with sophisticated local branching rules. But it has also been noticed that using the global structure of input graphs complements the the search tree paradigm. Here we prove some new results based on the global structure of bounded-degree graphs after branching away the high-degree vertices. Some techniques and structural results are generic and should find more applications. First, we decompose a graph by “separating” branchings into cheaper or smaller components wich are then processed separately. Using this idea we accelerate the O∗(1.3803k) time algorithm for counting the vertex covers of size k (Mölle, Richter, and Rossmanith, 2006) to O∗(1.3740k). Next we characterize the graphs where no edge is in three conflict triples, i.e., triples of vertices with exactly two edges. This theorem may find interest in graph theory, and it yields an O∗(1.47k) time algorithm for Cluster Deletion, improving upon the previous O∗(1.53k) (Gramm, Guo, Hüffner, Niedermeier, 2004). Cluster Deletion is the problem of deleting k edges to destroy all conflict triples and get a disjoint union of cliques. For graphs where every edge is in O(1) conflict triples we show a nice dichotomy: The graph or its complement has degree O(1). This opens the possibility for future improvements via the above decomposition technique. 1 The Problems and Contributions A problem is fixed-parameter tractable (FPT) if it can be solved in O(p(n)f(k)) time where p is a polynomial and f any function. We assume familiarity with the basic notions of FPT algorithms and their analysis [5, 13]. Since we focus on the f(k) factor, we sometimes adopt the O∗(f(k)) notation that suppresses polynomial factors. In graphs we usually denote by n the number of vertices. For brevity we say “component” instead of “connected component” of a graph. Counting Vertex Covers: A vertex cover is a set of vertices with at least one vertex from every edge. The problem of counting all vertex covers of size k in graphs (or more generally, hitting sets of size k in hypergraphs of fixed rank) is very natural as such, but has also interesting applications in combinatorial inference, e.g., in computational biology as proposed in [3]. Briefly, the real problem is to infer a set of substances that produced a given set of indicators, where an indicator may come from several candidate substances. Substances and indicators are modeled as vertices and edges of a hypergraph. Since many different solutions of a certain expected size exist, we count the solutions containing every fixed vertex, in order to evaluate how likely the presence of every substance is. Many vertex cover variants have been studied as well, see, e.g., [11] for pointers. The Vertex Cover Counting algorithm in [12] first branches on vertices of degree 4 or larger. The branching vector (1, 4) has branching number 1.3803, and vertex covers in the residual graphs of degree 3 can be counted in O∗(1.26k) time by a nontrivial technique. This gives an overall time bound of O∗(1.3803k), where the (1, 4)-branching is the bottleneck. In order to take this hurdle we must avoid the situation that only (1, 4)-branching takes place and cheaper rules are never invoked. Our idea is to reuse the above algorithm but choose the initial (1, 4)-branchings in a special way that guarantees a “large and easy” residual graph. We either retain one large degree-3 component that can be solved in O∗(1.26k) time (with the residual k), or we can split the residual graph into several components, process them independently, and finally combine the partial results in polynomial time. Loosely speaking, due to this quasi-parallelization of the remaining branchings, only one component with the largest residual k counts for the exponential term in the complexity. In all cases this drives the overall branching number below 1.3803. The fact that components of a graph can be treated independently is usually not even worth mentioning as it cannot be exploited in a worst-case analysis, but in our approach it becomes essential. The time analysis is not straightworward either. Upon the (1, 4)-branchings we deduct not only 1 and 4 from parameter k, but also the number of vertices that will be added later to the vertex covers in a cheaper way. On the other hand, we must “charge” the (1, 4)-branchings for these deferred decisions and increase the size bounds of the search trees after the branching accordingly, as every leaf in the search tree now represents the deferred decisions. But since they are cheaper, this pays off in the end. This global technique of branching away the hardest parts and splitting the rest into independent pieces seems to be new in this form. The idea is not deep, but this may be a strength. The conceptual simplicity should make it versatile and also applicable to other FPT problems that decompose neatly. The bound forVertex Cover Counting we can prove so far isO∗(1.3740k). Seemingly this is marginal progress, however, the weakness is apparently in the current analysis rather than in the algorithm itself. Our analysis gives something away, hence the true worst-case bound is likely to be way better. But it is hard to take advantage of those observations, since different bad cases can appear mixed throughout the search tree. (Cf. also [6, 7].) Cluster Modification Problems: A cluster graph is a disjoint union of cliques, also called clusters. A P3, or conflict triple, is a path of three vertices (and two edges). Cluster graphs are exactly the graphs without induced P3. In Cluster Deletion we want to delete at most k edges in a graph G so as to obtain a cluster graph. That is, deletions must destroy all induced P3. Cluster Editing is similarly defined with edge deletions and insertions. Both problems are special cases of Weighted Cluster Editing where pairs of vertices have individual edits costs. These NP-hard problems [14] have also applications foremost in computational biology [4, 9, 14]. Cluster Deletion becomes important if only adjacent vertices (representing similar objects) are tolerated in any cluster. The parameterized complexity of these problems is well studied. In [2] we give problem kernels and algorithms for enumerating all solutions to several clustering problems. In [1], Weighted Cluster Editing has been solved in O(1.82+n) time. This is also the best known time bound for Cluster Editing. The other special case is still somewhat “easier”: an O(1.53 + n) time algorithm for Cluster Deletion is known from [8]. It was an example of an automatically generated search tree algorithm and improved a “handmade” O(1.77 + n) algorithm [9]. It works with branching rules on subgraphs with at most six vertices. No further progress on Cluster Deletion has been made since then. Here we come back to handicraft and give an O(1.47 + n) time algorithm for Cluster Deletion. It starts from the most obvious rule with branching number 1.47: If some edge is in three or more P3, then branch on the edge, i.e., delete the edge, or delete all edges building a P3 with it. Key to our improvement is a new theorem showing that graphs where this rule is not applicable have simple structures, and no other local branching rules are needed. (Only special cases were already treated in [1, Lemma 4] and in a conference version of [2].) The result give new indications that local branching rules should be complemented by global structure analysis and techniques. Other global methods like dynamic programming on subsets, bounded treewidth and pathwidth [6, 7], and iterative compression [10], have recently shown their great potential. In fact, the O(1.3803) algorithm for Weighted Vertex Cover in [6] is close to the Vertex Cover Counting results, but here we add our separation idea. Organization of the paper: In Section 2 we state our algorithm for Vertex Cover Counting. It builds upon [12] and is only slightly more complicated. The only new features are that we branch on vertices of degree 4 in some breadthfirst order and combine partial results from different components in moderate polynomial time. (The polynomial factor has not been explicitly specified in [12], but we can obviously state that it does not blow up by the routines we add.) In Section 3 we prove a time bound that beats O∗(1.3803k), and we discuss why the true bound should be even better. Then we turn to some graph theory useful for clustering. In Section 4 we completely characterize the graphs where no edge is in three P3. In the proof we tried to avoid too many tiresome case distinctions. More generally, for graphs where every edge is in an O(1) number of P3 we prove a dichotomy: the graph or its complement graph has degree O(1). Section 5 deals with the algorithmic consequences of P3 structure. We solve Cluster Deletion in O∗(1.47k) time. Improving some details in the polynomial-time parts seems quite possible, however, the more intriguing question is about improved bases of the exponential term. We have to leave this for further research, but, using the above dichotomy we can at least show that the bottleneck case is graphs with bounded degree, and therefore it may be possible to apply the separation technique again. We discuss these possibilities also for Cluster Editing. Due to the page limit, some simpler proofs are omitted, graph-theoretic notions are only briefly reviewed, and there is no space for figures. 2 Vertex Cover Counting Algorithm Let c(G, k) be the number of vertex covers with exactly k vertices in graph G. The degree of a vertex v is the number of vertices adjacent to v. A degree-d vertex has degree exactly d. The degree of a graph is the maximum vertex degree. A subcubic graph has degree 3. We skip the definition of tree decomposition, because we use the following result only as a “black box”: Any subcubic graph has a tree decomposition of width at most (1/6 + )n, and such a tree decomposition is computable in polynomial time for any fixed > 0 [7]. By dynamic programming on this tree decomposition one can count the vertex covers of size k in O∗(2(1/3+ ) = O∗(1.26k) time [12], thus we have: Lemma 1. In subcubic graphs G one can compute c(G, k) in O∗(1.26k) time. If G is the disjoint union of graphs G1 and G2 then, obviously, c(G, k) = ∑k j=0 c(G1, j) · c(G2, k − j). From this one easily concludes: Lemma 2. Once the c(G′, j) are known for all components G′ of G, and for all j ≤ k, we can compute c(G, k) in polynomial time. Branching on a vertex v means: Either put v or all neighbors of v in the vertex cover, remove the chosen vertices, all incident edges, and isolated vertices. We refer to a series of such branching decisions on different vertices as a branch. Thus, a branch corresponds to a node of the resulting search tree. The residual graph in a branch is the graph that remains after the branchings. Note that branching on a vertex divides the family of vertex covers of the current residual graph exactly in two subfamilies of the vertex covers of residual graphs in the two new branches. Hence, when the search tree is completed, we can sum up the numbers of vertex covers (of the proper size) found in the residual graphs at the leaves. Now we describe our algorithm. Phase 1: preparation. First branch, as long as possible, on degree-d vertices with d ≥ 5. In every branch consider the residual graph of degree 4 and continue as described below. We will declare certain vertices roots. Phase 2: separation. If a component without a root exists, then fix any vertex in this component as the active root and proceed as follows. Layer j contains the vertices at distance j from the active root. As long as degree-4 vertices exist in some layer j > 2 of this component, choose one such degree-4 vertex closest to the active root and branch on it. (Note that these branchings may change the layers, and even disconnect some vertices from the active root.) This process stops as soon as no degree-4 vertices remain in the layers j > 2. At this moment, set the active root passive. – Iterate. Phase 3: completion. Branch on the remaining degree-4 vertices near the roots. This results in a subcubic graph. Let m ≤ k be the number of vertices that remain to be added to the vertex cover. (Note thatm depends on the branch but is exactly known in every branch.) Compute the c(G′, i) in all components G′ of the residual graph, and for all i ≤ m, using the algorithm in Lemma 1. Finally combine these results in every residual graph, to compute the number of vertex covers of size k, using the algorithm in Lemma 2. In the last step, the counts from all leaves of the search tree are added. Some refinement: For phase 2 we refine the rule for selecting the next degree-4 vertex to branch on. This is only a technicality that we insert just because we can prove a better worst-case bound when using it. Whenever a new layer j for branching is entered (that is, j > 2 is the smallest index of a layer where still degree-4 vertices exist), pair up some degree-4 vertices in layer j to siblings: Every degree-4 vertex in layer j is assigned an adjacent parent vertex in layer j − 1. (If several possible parent vertices exist, then select any one.) Siblings are degree-4 vertices with the same parent. It is not hard to see that, for j > 3, every degree-4 vertex gets at most one sibling. Now, whenever we have branched on a degree-4 vertex v and added v to the vertex cover (this happens in one branch), and v has a sibling which is still a degree-4 vertex, then branch on this sibling immediately.